"Hello, World!"

The first program you need to learn in any language is called, "Hello, World!" and its purpose is to simply print the words "Hello, World!" to the screen. In Java it looks like this.

$ javac Hello.java

$ java Hello
Hello, world

There is quite a lot of strange words and symbols in this code, you don't need to worry too much about what they mean at this point.

Already in this simple program there are some advanced concepts:

1. The text inside quotes is a string constant. It is effectively just a list of characters.
2. Method calls: System.out.println("Hello, world") is an example of a call to the println() method. A method is like a task or unit of work. Syntactically, it looks like a word followed by one or more items in parenthesis. The println() method prints an arbitrary string of characters on the screen.
3. Semi-colons: The semi-colon is used by Java to divide up the individual commands we give to the program. In this example there is only one command, and that command is to print the string "Hello, world" to the screen.
4. Arguments: The string "Hello, world" is called an argument, and we say that we are passing the argument "Hello, world" to the println() method.
5. Method definitions: main(String[] args) is an example of a method definition. Note the parentheses and also the curly brackets, i.e. the {}'s signify that we have a method definition. This main() method always prints the specific string "Hello, world" to the screen. To write a java program you must write a static method named "main". By convention, this is the place where java begins execution of your program.
6. Class: For now, think of a class as just a means of categorizing things. The main() method we are defining lives inside a class named Hello. Your class name should always match your file name, and class names should always begin with a capital letter.

$ javac Math1.java

$ java Math1
string concatenation
3
this is a three: 3
3+7/3-4=1
3.0+7.0/3.0-4.0=1.333333333333334
done

New things here:

1. The body of our main() function now has four commands in it, instead of just one. Notice that each of them terminates with a semicolon.
2. Line 3 uses the concept of string concatenation. In other words, we can write two strings and use + to join them together.
3. Line 4 is our first example of a numeric constant. Specifically it is the integer 3.
4. Line 5 adds an integer to a string. Java always knows how to convert something to a string, be it an integer, or some more advanced data type. It implicitly makes the conversion, concatenates the strings to one string, and generates output.
5. Line 6 adds a mathematical expression to a string. The Java compiler will follow normal mathematical ordering -- it will do multiplies before adds, allow grouping of expressions using parentheses, etc. Notice that no decimal points are used. As a result, this is an example of integer math. When doing integer math, remainders are ignored. Thus, 7/3 is just 2.
6. Line 7 is like line 6 but uses double precision math. The presence of a decimal point is what makes the difference. In double precision math, remainders are not ignored.

$ javac Ops.java

$ java Ops
integer:
  10/3=3
  10*3=30
  10%3=1
  10+3=13
  10-3=7
  10 & 3=2
  10 ^ 3=9
  10 | 3=11
floating point:
  10.0/3.1=3.225806451612903
  10.0*3.1=31.0
  10.0+3.1=13.1
  1.0e1-3.1=6.9

Here we see a more complete enumeration of the mathematical operators available to us for doing both integer and floating point arithmetic. Notice in the last line we've written "10.0" as "1.0e1". This is a kind of scientific notation, a shorthand for 1.0 * pow(10,1).

Note the logical operations available to us for the integer values. Don't worry too much if you don't know what logical and, or, and exclusive or are. We'll get back to these concepts later.

We also introduced comments: Everything after a // is ignored by the compiler. We can do this to write all kinds of helpful explanations into our code.